package com.sybil.spa.controlador;

import com.sybil.spa.dominio.Evento;
import com.sybil.spa.dominio.Flujo;
import com.sybil.spa.dominio.Paso;
import com.sybil.spa.dominio.Responsable;
import com.sybil.spa.servicio.FlujoServicio;
import java.util.HashMap;
import javax.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/flujos")
public class FlujoControlador {

   @Autowired
   private FlujoServicio flujoServicio;

   @RequestMapping(method = RequestMethod.GET)
   public String todos(Model model) {
      model.addAttribute("flujos", flujoServicio.obtenerFlujos());
      return "flujo/listado";
   }

   @RequestMapping(value = "/nuevo", method = RequestMethod.GET)
   public String formularioFlujoNuevo(Model model) {
      Flujo flujo = new Flujo();
      flujo.setValidaMonto("S");
      model.addAttribute(flujo);
      return "flujo/nuevo";
   }

   @RequestMapping(value = "/nuevo", method = RequestMethod.POST)
   public String flujoNuevo(@Valid @ModelAttribute Flujo flujo, BindingResult result) {
      if (result.hasErrors()) {
         return "flujo/nuevo";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         flujo.setUsuarioCreo(usuarioActual);
         flujoServicio.guardar(flujo);
         return "redirect:/flujos/pasos?cf=" + flujo.getClave();
      }
   }

   @RequestMapping(value = "/edit", params = "cf", method = RequestMethod.GET)
   public String formularioFlujoEditar(@RequestParam("cf") String claveFlujo, Model model) {
      model.addAttribute(flujoServicio.obtenerFlujo(claveFlujo));
      return "flujo/editar";
   }

   @RequestMapping(value = "/edit", params = "cf", method = RequestMethod.POST)
   public String flujoEditar(@Valid @ModelAttribute Flujo flujo, BindingResult result) {
      if (result.hasErrors()) {
         return "flujo/editar";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         flujo.setUsuarioModif(usuarioActual);
         flujoServicio.editar(flujo);
         return "redirect:/flujos";
      }
   }

   @RequestMapping(value = "/pasos", params = "cf", method = RequestMethod.GET)
   public String pasosDelFlujo(@RequestParam("cf") String claveFlujo, Model model) {
      Paso paso = new Paso(claveFlujo, null);
      paso.setEnviaAviso("S");
      paso.setTipo("M");
      paso.setJerarquico("N");
      paso.setFinalCorrecto("N");
      model.addAttribute(paso);
      model.addAttribute("flujo", flujoServicio.obtenerFlujo(claveFlujo));
      return "flujo/paso/nuevo";
   }

   @RequestMapping(value = "/pasos", params = "cf", method = RequestMethod.POST)
   public String pasosDelFlujoGuardar(@Valid @ModelAttribute Paso paso,
           BindingResult result, Model model) {
      if (result.hasErrors()) {
         model.addAttribute("flujo", flujoServicio.obtenerFlujo(paso.getLlave().getClaveFlujo()));
         return "flujo/paso/nuevo";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         paso.setUsuarioCreo(usuarioActual);
         flujoServicio.guardar(paso);
         return "redirect:/flujos/pasos?cf=" + paso.getLlave().getClaveFlujo();
      }
   }

   @RequestMapping(value = "/pasos", params = {"cf", "cp"}, method = RequestMethod.GET)
   public String formularioPasoEditar(@RequestParam("cf") String claveFlujo,
           @RequestParam("cp") String clavePaso, Model model) {
      model.addAttribute(flujoServicio.obtenerPaso(claveFlujo, clavePaso));
      return "flujo/paso/editar";
   }

   @RequestMapping(value = "/pasos", params = {"cf", "cp"}, method = RequestMethod.POST)
   public String pasoEditar(@Valid @ModelAttribute Paso paso, BindingResult result) {
      if (result.hasErrors()) {
         return "flujo/paso/editar";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         paso.setUsuarioModif(usuarioActual);
         flujoServicio.editar(paso);
         return "redirect:/flujos/pasos?cf=" + paso.getLlave().getClaveFlujo();
      }
   }

   @RequestMapping(value = "/pasos/elim", params = {"cf", "cp"}, method = RequestMethod.GET)
   public String pasoElimnar(@RequestParam("cf") String claveFlujo, @RequestParam("cp") String clavePaso) {
      flujoServicio.eliminarPaso(claveFlujo, clavePaso);
      return "redirect:/flujos/pasos?cf=" + claveFlujo;
   }

   @RequestMapping(value = "/eventos", params = {"cf", "cp"}, method = RequestMethod.GET)
   public String eventosDelFlujo(@RequestParam("cf") String claveFlujo,
           @RequestParam("cp") String clavePaso, Model model) {
      Evento evento = new Evento(claveFlujo, clavePaso, null);
      evento.setRequiereCausa("N");
      evento.setTipoAprobacion("T");
      evento.setValidaForzosos("N");
      model.addAttribute(evento);
      model.addAttribute("paso", flujoServicio.obtenerPaso(claveFlujo, clavePaso));
      model.addAttribute("pasos", flujoServicio.obtenerPasosFlujo(claveFlujo));
      return "flujo/evento/nuevo";
   }

   @RequestMapping(value = "/eventos", params = {"cf", "cp"}, method = RequestMethod.POST)
   public String eventosDelFlujoGuardar(@Valid @ModelAttribute Evento evento,
           BindingResult result, Model model) {
      if (result.hasErrors()) {
         model.addAttribute("paso", flujoServicio.obtenerPaso(evento.getLlave().getClaveFlujo(), evento.getLlave().getClavePaso()));
         model.addAttribute("pasos", flujoServicio.obtenerPasosFlujo(evento.getLlave().getClaveFlujo()));
         return "flujo/evento/nuevo";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         evento.setUsuarioCreo(usuarioActual);
         flujoServicio.guardar(evento);
         return "redirect:/flujos/eventos?cf=" + evento.getLlave().getClaveFlujo() + "&cp=" + evento.getLlave().getClavePaso();
      }
   }

   @RequestMapping(value = "/eventos", params = {"cf", "cp", "ce"}, method = RequestMethod.GET)
   public String formularioEventoEditar(@RequestParam("cf") String claveFlujo,
           @RequestParam("cp") String clavePaso, @RequestParam("ce") String claveEvento,
           Model model) {
      model.addAttribute(flujoServicio.obtenerEvento(claveFlujo, clavePaso, claveEvento));
      model.addAttribute("pasos", flujoServicio.obtenerPasosFlujo(claveFlujo));
      return "flujo/evento/editar";
   }

   @RequestMapping(value = "/eventos", params = {"cf", "cp", "ce"}, method = RequestMethod.POST)
   public String eventoEditar(@Valid @ModelAttribute Evento evento,
           BindingResult result, Model model) {
      if (result.hasErrors()) {
         model.addAttribute("pasos", flujoServicio.obtenerPasosFlujo(evento.getLlave().getClaveFlujo()));
         return "flujo/evento/editar";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         evento.setUsuarioModif(usuarioActual);
         flujoServicio.editar(evento);
         return "redirect:/flujos/eventos?cf=" + evento.getLlave().getClaveFlujo() + "&cp=" + evento.getLlave().getClavePaso();
      }
   }

   @RequestMapping(value = "/eventos/elim", params = {"cf", "cp", "ce"}, method = RequestMethod.GET)
   public String eventoElimnar(@RequestParam("cf") String claveFlujo,
           @RequestParam("cp") String clavePaso, @RequestParam("ce") String claveEvento) {
      flujoServicio.eliminarEvento(claveFlujo, clavePaso, claveEvento);
      return "redirect:/flujos/eventos?cf=" + claveFlujo + "&cp=" + clavePaso;
   }

   @RequestMapping(value = "/responsables", params = {"cf", "cp"}, method = RequestMethod.GET)
   public String responsablesDelFlujo(@RequestParam("cf") String claveFlujo,
           @RequestParam("cp") String clavePaso, Model model) {
      Responsable responsable = new Responsable(claveFlujo, clavePaso, null);
      responsable.setEsAprobador("S");
      responsable.setRecibeCopia("N");
      responsable.setUltimoAprueba("N");
      responsable.setForzoso("S");
      model.addAttribute(responsable);
      model.addAttribute("paso", flujoServicio.obtenerPaso(claveFlujo, clavePaso));
      model.addAttribute("usuarios", flujoServicio.obtenerUsuarios());
      return "flujo/responsable/nuevo";
   }

   @RequestMapping(value = "/responsables", params = {"cf", "cp"}, method = RequestMethod.POST)
   public String responsablesDelFlujoGuardar(@Valid @ModelAttribute Responsable responsable,
           BindingResult result, Model model) {
      if (result.hasErrors()) {
         model.addAttribute("paso", flujoServicio.obtenerPaso(responsable.getLlave().getClaveFlujo(), responsable.getLlave().getClavePaso()));
         model.addAttribute("usuarios", flujoServicio.obtenerUsuarios());
         return "flujo/responsable/nuevo";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         responsable.setUsuarioCreo(usuarioActual);
         flujoServicio.guardar(responsable);
         return "redirect:/flujos/responsables?cf=" + responsable.getLlave().getClaveFlujo() + "&cp=" + responsable.getLlave().getClavePaso();
      }
   }

   @RequestMapping(value = "/responsables", params = {"cf", "cp", "cu"}, method = RequestMethod.GET)
   public String formularioResponsableEditar(@RequestParam("cf") String claveFlujo,
           @RequestParam("cp") String clavePaso, @RequestParam("cu") String claveUsuario,
           Model model) {
      model.addAttribute(flujoServicio.obtenerResponsable(claveFlujo, clavePaso, claveUsuario));
      return "flujo/responsable/editar";
   }

   @RequestMapping(value = "/responsables", params = {"cf", "cp", "cu"}, method = RequestMethod.POST)
   public String responsableEditar(@Valid @ModelAttribute Responsable responsable,
           BindingResult result) {
      if (result.hasErrors()) {
         return "flujo/responsable/editar";
      } else {
         HashMap<String, Object> info = (HashMap<String, Object>) SecurityContextHolder.getContext().getAuthentication().getDetails();
         String usuarioActual = (String) info.get("clave");
         responsable.setUsuarioModif(usuarioActual);
         flujoServicio.editar(responsable);
         return "redirect:/flujos/responsables?cf=" + responsable.getLlave().getClaveFlujo() + "&cp=" + responsable.getLlave().getClavePaso();
      }
   }

   @RequestMapping(value = "/responsables/elim", params = {"cf", "cp", "cu"}, method = RequestMethod.GET)
   public String responsableElimnar(@RequestParam("cf") String claveFlujo,
           @RequestParam("cp") String clavePaso, @RequestParam("cu") String claveUsuario) {
      flujoServicio.eliminarResponsable(claveFlujo, clavePaso, claveUsuario);
      return "redirect:/flujos/responsables?cf=" + claveFlujo + "&cp=" + clavePaso;
   }

   @RequestMapping(value = "/vali", params = "cf", method = RequestMethod.GET)
   public String validarFlujo(@RequestParam("cf") String claveFlujo, Model model) {
      String validacion = flujoServicio.validar(claveFlujo);
      if (validacion != null && !"".equals(validacion)) {
         model.addAttribute("validacion", validacion);
         return "flujo/no_valido";
      }
      return "redirect:/flujos";
   }

   @RequestMapping(value = "/copi", params = {"cf", "cn"}, method = RequestMethod.GET)
   public String copiarFlujo(@RequestParam("cf") String claveFlujo, @RequestParam("cn") String claveFlujoNueva) {
      flujoServicio.copiar(claveFlujo, claveFlujoNueva);
      return "redirect:/flujos";
   }

   @RequestMapping(value = "/inac", params = "cf", method = RequestMethod.GET)
   public String inactivaFlujo(@RequestParam("cf") String claveFlujo) {
      flujoServicio.inactivar(claveFlujo);
      return "redirect:/flujos";
   }
}
